googologywikiaorg-20200223-history
User blog:KthulhuHimself/Norminals Revisited.
Too lazy to make an intro. One-entry Let's start with N<0>(n), and define it identically to FOST(10^n). Then, we make a small ruleset for N(n) (a being an ordinal). Notes *N is a language, N(n) is a function that uses N. Ruleset N is N with quantification over the predicates of N. If a is a limit ordinal in N, add a new syntax as follows: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value, smaller than a, in some assignment, then we interpret x as y-th order variable. (half-quoted from user "Littlepeng9") Otherwise, treat y as omega. First cases of two-entry The smallest N<#> (norminal) that uses more that one entry is N<0,1>. Define it as follows: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value in some assignment, then we interpret x as y-th order variable. It's simpler and more expressive than any one entry norminal, so we can surely say this is progress! A bit further Define the following ruleset for N(n): N is N with quantification over the predicates of N. If a is a limit ordinal in N, add a new syntax as follows: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value, smaller than a, in some assignment, then we interpret x as -th order variable. Otherwise, treat y as omega. N<0,1> uses the following syntax: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value in some assignment, then we interpret x as y-th order variable. Similarly, N<<0,1>,1> uses the following syntax: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value in some assignment, then we interpret x as -th order variable. We extend to N<,1> (for limit ordinals), using the following syntax: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value, smaller than a, in some assignment, then we interpret x as <,1>-th order variable. Otherwise, treat y as omega. We now have N<<<0,1>,1>,1>(n), N<<<<0,1>,1>,1>,1>(n), etc. defined in the same way. To N<0,2>, and for finite n Simple. If a subformula of form x(y) exists, where x and y are variable symbols where y takes some Ao value smaller than <0,2> in some assignment, then we interpret x as a y-th order variable. If need be, the symbols "<", ",1>" can be added to the language for internal reference. Extension to N<0,3>, N<0,4>, etc. is straightforward. With ordinals We can pretty much copy the logic used in N to the logic in N<0,a>. From the higher two-entries to the first three-enties Lets start with the straightforward N<0,<0,1>>(n): N<0,<0,1>> uses the following syntax: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some Ao value smaller than <0,<0,1>> in some assignment, then we interpret x as y-th order variable. We can now increase to N<0,<0,a>>(n), N<0,<0,<0,1>>>(n), etc., with no problems. Extension to N<0,0,1>(n) is nearly trivial: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some ordinal value smaller than <0,0,1> in some assignment, then we interpret x as y-th order variable. More entries Extension to four-entry, five-entry, omega-entry, etc. is obvious. Defining higher array-ordinals and norminal orders Now that we have N<0,0,1>(n), N<0,0,0,0,0,0,1>(n), N<0,0,0,..(w zeroes)..,0,1>(n), N<0,0,0,..(<0,1> zeroes)..,0,1>(n), etc. defined, we can now move on to some obligatory extensions. Apllying TaN separator logic to Aos It was not a coincedence that I chose the same notation to express array ordinals and terminal arrays, as the way I intend to extend Aos uses the same methodology that separators use in TaN. N<0<1>1> First off, I will revise the visual appearance of all the Aos definde so far in order to appeal more to the extention, by replacing any instance of ",", with "<0>". For example, N<0,0,1>(n) will now be written N<0<0>0<0>1>(n) Now, we define N<0<1>1> as follows: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some Ao value smaller than <0<1>1> in some assignment, then we interpret x as y-th order variable. (The array ordinal <0<1>1> is the successor of all array ordinals using <0> separators.) If need be, the symbols "<", "<0>" and ">" can be added to the language for internal reference. Larger instances of <#<1>n> Extension to N<1>1>, N<(some array only using <0> separators)<1>1>, and similar norminals uses the same logic as before. Define N<0<1>2> identically to N<0<1>1>, but with the following changes: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some Ao value smaller than <0<1>2> in some assignment, then we interpret x as y-th order variable. (The array ordinal <0<1>2> is the successor of all array ordinals using <0> separators until the last separator in the array, which can be a <1> separator.) If need be, the symbols "<", "<0>", "<1>" and ">" can be added to the language for internal reference. <1>n> for any natural n Just the same process as before; generalised: N<0<1>n>: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some Ao value smaller than <0<1>n> in some assignment, then we interpret x as y-th order variable. For ordinals and Aos Same logic as before. Extending to <#<2>#*> and onwards Simple: N<0<2>1>: If a subformula of form x(y) exists, where x and y are variable symbols where y takes some Ao value smaller than <0<2>1> in some assignment, then we interpret x as y-th order variable. (The array ordinal <0<2>1> is the successor of all array ordinals using <0> separators and <1> separators.) Extension to <3> separators, separators, <0<0>1> separators, etc. and onwards is obvious; allowing us to get some unspeakable numbers such as N<0<0<0<1>1>1>1>(100); but we can extend this even further... Final fully explained extension (well, it's actually just a genrealisation for all future extensions, so that I can be more concise and stick to what matters.) N<$> (for any well-defined norminal $): If a subformula of form x(y) exists, where x and y are variable symbols where y takes some norminal value smaller than $ in some assignment, then we interpret x as y-th order variable. Simple; so from now on, I will stick more to defining the norminals themselves than the actual functions, as doing so will be just as sufficient. (If you have any objections, feel free to place them in the comments.) Array ordinals It's about time I defined this. Array ordinals (or Ao (pl. Aos) for short) are the symbols introduced in N<0,1> and forth, that are used to create higher orders for the various Norminal functions I have defined so far. An array ordinal is an group of objects that all behave very similarly to regular ordinals, yet are not in fact actual ordinals (somewhat like oodinals). To explain this in an easier way, imagine that all ordinals are actually a type of array ordinal, denoted as 0 Aos, and that the array ordinals I've introduced so far (among some other) are 1 Aos. In general, a+1 Aos are used as the limit of all a Aos. For example, <0,1>, is defined as the successor of all ordinals, or all 0 Aos (to clarify, <0,0,1> is still a 1 Ao, and not a 2 Ao). Analysing So far, we can see how the functions created are fast growing. Take for example the weakest function of them all: N<0>(n). N<0>(n) A few values While no precise values can be given, some useful bounds can be assumed. N<0>(1) uses 10 FOST symbols, and so most likely can define zero, hence: N<0>(1) = 1. N<0>(2) uses 100 symbols, and so most likely is capable of defining weak functions such as successor, hence can probably reach 2, hence: N<0>(2) > 3. With 1,000 symbols, FOST can most likely define some far stronger functions (Vell had claimed to create the busy beaver with only 500!), so a wild guess, and a decent lower bound would be: N<0>(3) > Googolplex. We propel this into 10,000 symbols at N<0>(4), so at this point, it is safe to say that: N<0>(4) > Sigma(1,000). N<0>(10) >> Xi(10^6). N<0>(100) = Rayo's number. N<1>(n) All the above is only in N<0>(n), but what if we use N<1>(n)? N<1>(6) can probably define FOST(n) (as it most likely requires less than one million symbols), hence N<1>(7) is already much larger than Rayo's number. Needless to say, N<1>(100) is much, much, larger than Rayo's number. For larger finite a (N(n)) In general, N<2>(100) is probably larger than N<1>(n), for any meaningful n, the same being true about larger values such as N<3>(100), N<10>(1,000), N<100>(10,000), etc. N(n) N(100) is most likely larger than N<(Rayo's number)>(10^100), as a guess. N(n), for a few specific ordinals N(10^6) > Fish number 7 (most definently). More N<0,0,1>10(101) > BIG FOOT Nihillis functions The Nihilis function, or ]Nis a generalization of all the above, where n is any natural number, and m is some other natural number, predefined for every individual number. (Note: this is a naive extention.) Definition(s) N= 10 N= NN0(n-1)(10)N= 10 N= N<0,0,0,...,0,1>N(n zeroes) That's all so far. (And I'd say with certainty that Nis larger than BIG FOOT.) NOTE Because this is a naive extension (sort of), I will not use this form of the function anywhere else for the time being. IMPORTANT: I am removing the needless first entry from the notation. What I mean by this is that from now on, I won't bother expressing Aos as <0,#>, but rather as <#>; anything that was previously denoted will now be denoted <#>+a, this has obvious benefits and will now be canon for any future extensions I make. Definitions of norminals (Acka, array ordinals). Because the function is pretty much based around them, I think it would be best to explain their specific nature(s). Single entry Single entry norminals are pretty much the simplest things that go beyond regular ordinals, stating with <1>, and going on all the way to <<<...<1>...>>> (previously known as <0,<0,<0,...<0,1>>>). The definitions of these are already present earlier on the blog post, so I won't really elaborate much more (for now). For any number of entries Regular array ordinals consisting simply of a number of entries are defined quite simply as the limits to whatever Aos would use smaller Aos in them. With these, each further entry gets unlimitedly more consideration over the previous ones; for example, if I have the Ao <0,2> and the Ao <<0,1>,1>, the larger one will be <0,2> (second is considered more than the first). Same goes for entires which have a transfinite placement in the array (omegath, epslilonth, <1>'th etc.). All larger [1Aos "Countable" 1Aos For the sake of being concise, I will generalise the definition of all larger 1Aos in the following simple way (and because they're not as interesting as what follows); most larger 1Aos are simply reordering-limits of previous 1Aos (as are many ordinals, such as epsilon_0 and the SVO), much in a way similar to TaN is really just reordering-limits of BEAF-like arrays. (It's no coincedence that both TaN and Aos share the same notation.) Examples <0<1>1>, <01>, <0<0<1>1>1>, <0<1><1>1> "Uncountable"1Aos Obviously, we can make a 1Ao that is simply the limit to all such reordering; similarly to how omega_1 operates. (Proceeding with 1Aos that operate like omega_2, omega_omega, the OFP, etc.) No real need for examples or further elaboration, as these aren't as interesting as what's to follow. 2Aos It's time to move onto the REAL tasty stuff. Definition Let <1><1> be the limit to all 1Aos; and from here on until 3Aos, all the other rules are the same as with 1Aos. Because the examples are basically just 1Aos with a <1> slapped on the top left of them, there's no reason to show any. (Revised notation) (From now on, <1><1> will be expressed <1>;<1>) aAos I honestly don't know if I even need to write the definition down; shouldn't it be obvious? Write what you think in the comments below. The trivial definition is identical to how <#>;<#> would operate. Category:Blog posts